package manager

import (
	"battle-server/config"
	"game-server/model"
	"log"
	"sync"
)

// HeroCache 存储所有英雄数据的全局缓存
var (
	HeroCache        map[int]*model.Hero          // 英雄ID -> 英雄信息
	SkillCache       map[int]*model.Skill         // 技能ID -> 技能信息
	HeroSkillCache   map[int][]*model.Skill       // 英雄ID -> 该英雄所有技能
	SkillEffectCache map[int][]*model.SkillEffect // 技能ID -> 该技能所有效果
	heroCacheMutex   sync.RWMutex
)

// InitHeroData 从数据库加载英雄、技能和效果数据到内存
func InitHeroData() {
	log.Println("开始加载英雄数据...")

	// 初始化缓存映射
	HeroCache = make(map[int]*model.Hero)
	SkillCache = make(map[int]*model.Skill)
	HeroSkillCache = make(map[int][]*model.Skill)
	SkillEffectCache = make(map[int][]*model.SkillEffect)

	// 加载所有英雄数据
	var heroes []*model.Hero
	if err := config.DB.Find(&heroes).Error; err != nil {
		log.Printf("加载英雄数据失败: %v", err)
		return
	}

	// 将英雄数据存入缓存
	for _, hero := range heroes {
		HeroCache[hero.HeroID] = hero
	}

	log.Printf("已加载 %d 个英雄", len(heroes))

	// 加载所有技能数据
	var skills []*model.Skill
	if err := config.DB.Find(&skills).Error; err != nil {
		log.Printf("加载技能数据失败: %v", err)
		return
	}

	// 将技能数据存入缓存
	for _, skill := range skills {
		SkillCache[skill.SkillID] = skill

		// 构建英雄ID到技能列表的映射
		HeroSkillCache[skill.HeroID] = append(HeroSkillCache[skill.HeroID], skill)
	}

	log.Printf("已加载 %d 个技能", len(skills))

	// 加载所有技能效果数据
	var effects []*model.SkillEffect
	if err := config.DB.Find(&effects).Error; err != nil {
		log.Printf("加载技能效果数据失败: %v", err)
		return
	}

	// 将技能效果数据存入缓存
	for _, effect := range effects {
		SkillEffectCache[effect.SkillID] = append(SkillEffectCache[effect.SkillID], effect)
	}

	log.Printf("已加载 %d 个技能效果", len(effects))

	log.Println("英雄数据加载完成")
}

// GetHeroByID 根据ID获取英雄数据
func GetHeroByID(heroID int) *model.Hero {
	heroCacheMutex.RLock()
	defer heroCacheMutex.RUnlock()

	if hero, ok := HeroCache[heroID]; ok {
		return hero
	}
	return nil
}
